%Rapport sur la mise en oeuvre de QoS via Webmin-htb: (Pour Ubuntu)\\

Mon sujet principal pendant ce stage consiste à mettre en œuvre de la qualité de service sur
les parefeux de la société. Pour ce faire, je vais devoir étudier les différentes méthodes
existantes afin de mettre en place des règles telles que la gestion de bande-passante ou la
prioritisation de traffic sur les routeurs.\\

Avant de commencer, voici une petite explication de ce qu'est la qualité de service (QoS).
La QoS pour un routeur, cela inclu la gestion de la bande-passante, la gestion des priorités
et éventuellement de l'équilibrage de charge.\\

Le cahier des charges du projet est le suivant:\\

\begin{itemize}
	\item Pouvoir limiter la bande passante en fonction de la source et/ou du protocole.
	\item Pouvoir utiliser un surplus de bande passante lorsque celui-ci est disponible.
	\item Pouvoir rendre des services, des réseaux, des postes plus prioritaires.
	\item Utiliser un outil de gestion de bande passante graphique et simple à utiliser.
	\item Pouvoir visualiser cette gestion de bande passante à fin de développement.
	\item Rendre la démarche plus facile en essayant de la conjuguer avec FWBuilder.
	\item Rédiger une notice explicative sur cette mise en œuvre.\\
\end{itemize}

Afin de répondre à ces besoins, je commence par rechercher diverses solutions logicielles.
Voici donc une liste d'outils existants plus ou moins évolués permettant de gérer des règles
de qualité de services:\\

\begin{enumerate}
	\item Webmin-Htb:
	\begin{itemize}
		\item Webmin est un outil qui permet d'administrer une machine depuis une 
		interface web
		\item Webmin-Htb est un module pour "Webmin" permettant une mise en œuvre 
		efficace de règles de QoS
		\item Licence: GPL
		\item Dernière version: 0.1.1 Alpha - 2005
		\item Site officiel: \texttt{http://www.sehier.fr/webmin-htb/}\\
	\end{itemize}
	\item RCC:
	\begin{itemize}
		\item RCC est un logiciel de gestion de QoS pour Linux
		\item Licence: GPL
		\item Dernière version: 0.8 - Mars 2005
		\item Site officiel: \texttt{http://sourceforge.net/projects/rcc}\\
	\end{itemize}
	\item Wonder Shaper:
	\begin{itemize}
		\item Wonder Shaper est un outil en ligne de commande qui simplifie la gestion 
		de la commande TC
		\item Licence: GPL
		\item Dernière version: 1.1a - avril 2002
		\item Site officiel: \texttt{http://lartc.org/wondershaper/}\\
	\end{itemize}
	\item Trickle:
	\begin{itemize}
		\item Trickle est un outil qui permet de limiter la bande-passante en ligne de commande 
		pour des applications définies
		\item Ex: trickle -d 1 wget http://plan-net.lu/ permet de télécharger la page demandée 
		à la vitesse de 1ko/s
		\item Licence: BSD
		\item Dernière version: 1.07 - 2002 \\
	\end{itemize}
	\item Mastershaper:
	\begin{itemize}
		\item Interface web permettant la gestion de règles de QoS
		\item Licence: 
		\item Dernière version: 2007
		\item Site officiel: \texttt{http://www.mastershaper.org/index.php/Main\_Page}\\
	\end{itemize}
	\item QtMonitor:
	\begin{itemize}
		\item Outil de monitoring permettant de surveiller le respect des règles de QoS
		facilement
		\item Licence: GPL v2
		\item Dernière version: 1.0 - août 2007
		\item Site officiel: \texttt{http://rocher.daniel.free.fr/wiki/wakka.php?wiki=QtMonitor}\\
	\end{itemize}
\end{enumerate}

Pour réaliser la mise en place de règles de QoS, l'utilisation de Webmin-htb et de QtMonitor en 
parallèle permet un développement efficace. En effet, Webmin étant un outil très utilisé pour 
l'administration de machines, l'ajout d'un module afin de gérer la qualité de service semble être 
une bonne idée d'autant que l'outil Webmin est déjà en production sur les différents routeurs du
réseau. D'après les élements présentés ci-dessus, les outils les plus intéressants sont le module
Webmin-Htb et Master Shaper pour la gestion des règles de QoS et QtMonitor pour surveiller le 
traffic effectif sur le réseau d'après les classes qui auront été définies.\\

Master Shaper est un logiciel bien plus complexe que le module Webmin-Htb qui permet de définir
en profondeur des règles de qualité de service en choisissant le type de file d'attente  utilisée, 
Htb\footnote{Htb: Hierarchy Token Bucket}, HFSC\footnote{HFSC: Hierarchy ...} ou encore CBQ
\footnote{CBQ: }. Cependant, étant donné la demande, ce logiciel semble trop complexe ainsi, pour 
la suite, nous utiliserons le module Webmin-Htb.\\

\subsection{Mise en œuvre de Webmin-Htb}

Webmin-Htb étant un module pour "Webmin", il faut tout d'abord disposer de celui-ci 
sur le routeur(pare-feu) à configurer. Nous allons donc commencer par installer Webmin en passant 
par les dépôts d'Ubuntu. Le paquet nécessaire n'étant pas maintenu dans les dépôts officiels des 
dernières versions, il faut ajouter le dépôt source de \emph{Debian Sarge} pour l'installer avec 
le gestionnaire de paquets \emph{APT}.\\

\subsubsection{Installation de Webmin}

\begin{itemize}
	\item Ajouter la clé gpg du repository à ajouter au système:\\
	\verb?cd /root?\\
	\verb?sudo wget http://www.webmin.com/jcameron-key.asc?\\
	\verb?sudo apt-key add jcameron-key.asc?
	\item Ajouter la ligne suivante à /etc/apt/sources.list:\\
	\verb?deb http://download.webmin.com/download/repository sarge contrib?
	\item Installer Webmin:\\
	\verb?sudo apt-get update && sudo apt-get install webmin?
	\item Modifier le mot de passe pour Webmin:\\
	\verb?sudo /usr/share/webmin/changepass.pl /etc/webmin root votre\_mot\_de\_passe?
	\item Webmin est désormais accessible via:\\
	\verb?https://ip\_du\_routeur\_ou\_webmin\_est\_installé:10000/?\\
\end{itemize}

Nous avons maintenant un poste avec Webmin d'installé, nous pouvons donc passer à la suite, 
l'installation du module Webmin-Htb.\\

\subsubsection{Installation du module Webmin-Htb}

\begin{itemize}
	\item Copier le script htb.init dans /etc/init.d/\\
	\verb?http://sourceforge.net/projects/htbinit/?
	\item Installer la bibliothèque Perl nécessaire:\\
	\verb?cpan -i Tree::DAG\_Node?
	\item Installer Webmin-Htb via le gestionnaire de modules de Webmin:\\
	\verb?cd /usr/share/webmin/?\\
	\verb?wget http://www.sehier.fr/webmin-htb/webmin-htb.tar.gz?\\
	\verb?webmin -> webmin configuration -> webmin modules?\\
	\verb?indiquer l'emplacement du module et affecter les droits à un utilisateur?
	\item Le module est maintenant accessible sous:\\
	\verb?Networking -> Hierarchy Token Bucket Queuing?\\
\end{itemize}
	
Ce module étant en version alpha, les labels sur les boutons de l'interface ne sont par défaut
visibles que si l'interface Webmin est configurée en français. Pour palier à ce problème et 
permettre l'utilisation de ce module dans les autres langues, il suffit de créer un fichier
correspondant à la langue désirée à partir du fichier fr dans: \\

\verb?/usr/share/webmin/htb/lang?\\

Ainsi, pour pouvoir utiliser ce module convenablement dans la langue de son choix, il suffit de 
copier ce fichier, de le traduire (~10 lignes) et de le renommer selon le pays désiré.\\

\subsubsection{Configuration du module Webmin-Htb}

Maintenant que Webmin et le module Webmin-Htb sont installés, nous allons commencer la 
configuration de notre module. Avant tout, ce module sauvegarde ses données dans /etc/sysconfig/htb.
Il faut donc créer ce répertoire:\\

\verb?mkdir /etc/sysconfig/htb/?\\

Nous pouvons maintenant commencer la configuration de Webmin-Htb, que nous allons découvrir 
progressivement au travers de son interface web. Nous commençons donc par ouvrir l'url suivante 
sur \emph{Firefox}:\\

\verb?https://ip_du_routeur:10000/?\\

puis dans le menu de gauche:\\

\verb?Network -> Hierarchy Token Bucket?\\


\begin{figure}[H]
	\centering
	\includegraphics[scale=0.4]{texdata/images/001_interface.png}
        \caption{Interface du module Webmin-Htb}
\end{figure}
	
Nous allons maintenant créer une structure en arbre représentant les différentes
connexions intéressantes:\\
	
Par exemple pour 3 clients se partageant une connexion 2Mbit avec possibilité
d'utiliser le surplus de bande passante inutilisé par les autres clients:\\


\begin{figure}[H]
	\centering
	\includegraphics[scale=0.5]{texdata/images/config-test.png}
        \caption{Configuration de test sur Webmin-Htb}
\end{figure}
	
Pour créer une nouvelle branche dans la structure actuelle, il suffit de cliquer
sur la flèche située en bout de ligne.\\
	
Le rate indique la vitesse de connexion par défaut (celle réservée au client)\\
\texttt{ex: 2Mbit}\\
Le ceil indique la bande passante supplémentaire utilisable si disponible\\
\texttt{ex: 8Mbit}\\
La priorité indique l'ordre de priorité d'attribution de la bande passante\\
\texttt{ex: ssh prio=1, voip prio=2, dns prio=3, www prio=4}\\

Une fois la structure crée, il ne reste plus qu'à lancer le script en cliquant
sur le bouton de gauche "Démarrer le script htb.init"\\
	
Automatiser le lancement du script (au démarrage du système)\\

\verb?sudo update-rc.d -f htb.init defaults?\\

Les règles régissant la bande-passante sont maintenant crées et opérationnelles, 
cependant, il faut vérifier leur bon fonctionnement. C'est là qu'intervient QtMonitor
puisque celui-ci va nous permettre de vérifier le traffic de chaque classe crée.\\

\subsubsection{Visualisation des règles de QoS}

Avant même de commencer à utiliser QtMonitor afin de visualiser le traffic en cours 
dans chaque classe crée, commençons par vérifier si nos classes ont bien été prises en 
compte par le système en utilisant directement la commande TC:\\

\verb?tc -d class show dev ethXX? (ou ethXX est l'interface définie)\\

Si les classes sont bien définies, la réponse doit être une liste de \texttt{class htb …}
et nous pouvons visualiser le contenu de ces classes via QtMonitor que nous allons installer
dès à présent.\\
	
\subsection{Installation de QtMonitor}
QtMonitor fonctionne en mode client-serveur, il faut donc installer le serveur sur la machine 
à surveiller et le client sur un autre poste (ou le même si l'on travaille en local).\\

\begin{enumerate}
	\item Les dépendances nécessaires côté client et serveur:
	\begin{itemize}
		\item libpam0g-dev 
		\item g++ 
		\item libqt4-dev\\
	\end{itemize}	
	\item Compilation et installation du serveur:
	\begin{itemize}
		\item cd server
		\item qmake
		\item make
		\item sudo make install\\
	\end{itemize}
	\item Compilation et installation du client:
	\begin{itemize}
		\item cd client
		\item qmake
		\item make
		\item sudo make install\\
	\end{itemize}
	\item Génération des clés (ssl) sur le serveur:
	\begin{itemize}
		\item cd /etc/qtmonitord/
		\item openssl genrsa -des3 -out privkey.pem 2048 (clé privé - droit 640)
		\item saisir une passphrase
		\item Certificat autosigné avec la clé privkey.pem:
		\item openssl req -new -x509 -key privkey.pem -out server.pem -days 10000\\
	\end{itemize}
	\item Ajouter les utilisateurs autorisés à se connecter
	\begin{itemize}
		\item Les ajouter dans /etc/qtmonitord/qtmonitord.users\\
	\end{itemize}
	\item Démarrage du serveur:
	\begin{itemize}
		\item /etc/init.d/qtmonitord start\\
	\end{itemize}
\end{enumerate}	
	
QtMonitor nous permet de voir, sur le client, les différentes classes définies ainsi
que leur application sous forme de graphiques mais il permet également, en phase de 
développement de déterminer les noms des classes htb crées si l'on a du mal à comprendre
leur numérotation depuis l'interface Webmin-Htb qui ne correspond pas à un numéro de classe 
htb mais simplement au nom du fichier de config de cette branche.\\

Voici un exemple de visualisation de traffic:\\

\begin{figure}[H]
	\centering
	\includegraphics[scale=0.3]{texdata/images/qtmon.png}
        \caption{Aperçu du traffic dans les différentes classes définies}
\end{figure}
